/**
 * Copyright (c) Huawei Technologies Co., Ltd. 1987-2021. All rights reserved.
 */

package com.gitee.fufu669.utils;

import org.junit.Test;
import org.springframework.util.CollectionUtils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;

/**
 * 加注释
 */
public class CacheNoteLineUtil {

    // 赋值
    private static final String[] FILE_NAMES = {
        //"D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest33\\src\\main\\java\\com\\huawei\\ebg\\olblab\\onlinelab\\service\\ProjectLoginService.java",
        //"D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest27\\envcheck-common\\src\\main\\java\\com\\huawei\\ebg\\olblab\\envcheck\\common\\browser\\FireFoxCheck.java",
        "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest33\\src\\main\\java\\com\\huawei\\ebg\\olblab\\onlinelab\\aspect",
    };
    // 赋值
    private static final String[] SKIP_FILE_WHEN_MEET_THESE_LINES = {
        "package com.huawei.ebg.olblab.experiment.sub.common.experiment.sub"
    };
    // 赋值
    private static final String[] EXCLUDE_FILES = {
        "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest31\\src\\main\\java\\com\\huawei\\ebg\\olblab\\experiment\\sub\\common\\experiment"
    };

    // 赋值
    private static final String COPYRIGHT_STRING = " * Copyright (c) Huawei Technologies Co., Ltd. 1987-2021. All rights reserved.\n";
    // 赋值
    private static final int TRANSLATE_WORD_MIN_SIZE = 4;

    // 注解
    @Test
    /**
     *  自动增加注释
     */
    public void autoAddNote() {
        // 递归程序加注释
        addNoteToJava(FILE_NAMES, SKIP_FILE_WHEN_MEET_THESE_LINES, EXCLUDE_FILES, COPYRIGHT_STRING);
    }

    /**
     * 递归程序加注释
     */
    public static void addNoteToJava(String[] fileNames, String[] skipFileWhenMeetTheseLines, String[] excludeFiles, String copyrightString) {
        // 遍历
        for (String fileName : fileNames) {
            // 递归程序加注释
            addNoteToJava(fileName, skipFileWhenMeetTheseLines, excludeFiles, copyrightString);
        }
    }

    // 递归程序加注释
    private static void addNoteToJava(String fileName, String[] excludeLines, String[] excludeFiles, String copyrightString) {
        // 递归程序加注释
        addNoteToJava(new File(fileName), excludeLines, excludeFiles, copyrightString);
    }

    // 递归程序加注释
    private static void addNoteToJava(File file, String[] excludeLines, String[] excludeFiles, String copyrightString) {
        // 如果非空
        if (file != null) {
            // 如果是目录
            if (file.isDirectory()) {
                // 拿列表
                File[] filesInside = file.listFiles();
                // 遍历
                for (File fileInside : filesInside) {
                    // 递归程序加注释
                    addNoteToJava(fileInside, SKIP_FILE_WHEN_MEET_THESE_LINES, excludeFiles, copyrightString);
                }
                // 否则
            } else {
                // 判断
                if (file.getPath().contains("CacheNoteLineUtil.java")) {
                    // 打印
                    System.out.println(file.getPath());
                }
                // 遍历
                for (String excludeFile : excludeFiles) {
                    // 判断
                    if (file.getPath().contains(excludeFile)) {
                        // 返回
                        return;
                    }
                }
                // 判断
                if (!file.getPath().contains("\\test\\")
                    // 如果以.java结尾
                    && file.getName().endsWith(".java")) {
                    // 赋值
                    Boolean excludeLineFound = false;
                    // 创建
                    List<String> allLineList = new ArrayList<>();

                    // 尝试下面的代码
                    try (
                        // 创建
                        FileInputStream fileInputStream = new FileInputStream(file);
                        // 创建
                        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
                        // 创建
                        BufferedReader bufferedReader = new BufferedReader(inputStreamReader)
                    ) {
                        // 定义
                        List<String> prevLineList = new ArrayList<>();
                        // 赋值
                        String prevLine = "";
                        // 开始增加注释了
                        String noteLine = "";
                        // 定义
                        String line = null;
                        // 创建
                        StringBuilder stringBuilder = new StringBuilder();
                        // 赋值
                        int lineCount = 0;
                        // 读一行
                        while ((line = bufferedReader.readLine()) != null) {
                            // 增加
                            allLineList.add(line);
                        }
                        // 捕捉异常
                    } catch (Exception e) {

                    }
                    // 尝试下面的代码
                    try (
                        // 创建
                        FileInputStream fileInputStream = new FileInputStream(file);
                        // 创建
                        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
                        // 创建
                        BufferedReader bufferedReader = new BufferedReader(inputStreamReader)
                    ) {
                        // 定义
                        List<String> prevLineList = new ArrayList<>();
                        // 赋值
                        String prevLine = "";
                        // 开始增加注释了
                        String noteLine = "";
                        // 定义
                        String line = null;
                        // 创建
                        StringBuilder stringBuilder = new StringBuilder();
                        // 赋值
                        int lineCount = 0;
                        // 读一行
                        while ((line = bufferedReader.readLine()) != null) {
                            // 增加
                            lineCount += 1;
                            //判断是否跳出
                            for (String excludeLine : excludeLines) {
                                // 判断
                                if (line.trim().startsWith(excludeLine)) {
                                    // 返回
                                    return;
                                }
                            }
                            // 如果是空
                            if (CollectionUtils.isEmpty(prevLineList)) {
                                // 置成目前这行
                                prevLineList.add("first line");
                            }
                            // 把tab换成4个空格
                            line = line.replace("\t", "    ");
                            // 替换
                            line = line.replace(":// ", ":// ");
                            // 替换
                            line = line.replace("// ", "// ");
                            // 替换
                            line = line.replace("// ", "// ");
                            // 替换
                            line = line.replace(", ", ", ");
                            // 替换
                            line = line.replace(", ", ", ");
                            // 替换
                            line = line.replace(", \n", ",\n");
                            // 拿出
                            prevLine = prevLineList.get(prevLineList.size() - 1);
                            // 判断是否不需要增加注释
                            if (isNotNeedToAddNoteLine(line, prevLineList)) {
                                // 判断如果这行和上一行不相等
                                if (!line.equals(prevLine)) {
                                    // 连续2行是//的注释
                                    if (line.trim().startsWith("//") && prevLine.trim().startsWith("//")) {
                                        // 如果2行都是// 注释的话，就不增加当前的这行记录了
                                        System.out.println("skipped line in file:" + file.getPath() + ", prevLine:" + prevLine + ", line:" + line + "");
                                        // 否则
                                    } else {
                                        // 判断
                                        if (line.trim().startsWith("import ") & line.contains("*")) {
                                            // 打印
                                            System.out.println("file:" + file.getPath() + ", should skipped prevLine:" + prevLine + ", line:" + line);
                                            // 加入
                                            stringBuilder.append(line + "\n");
                                            // 判断
                                        } else if (line.trim().startsWith("public ") || line.trim().startsWith("protected")) {
                                            // 加入根据判断拿到注释行
                                            stringBuilder.append(getNoteLine(line, prevLineList, file, lineCount, copyrightString, allLineList));
                                            // 加入
                                            stringBuilder.append(line + "\n");
                                            // 否则
                                        } else {
                                            // 加入
                                            stringBuilder.append(line + "\n");
                                        }
                                    }
                                    // 否则
                                } else {
                                    //如果相同且当前行不是注释
                                    if (!isNoteLine(line)) {
                                        // 加入
                                        stringBuilder.append(line + "\n");
                                    }
                                }
                            }
                            // 否则
                            else {
                                // 判断如果上一行不是TODO
                                if (!prevLine.trim().replace(" ", "").equals("// TODO")) {
                                    // 加入根据判断拿到注释行
                                    stringBuilder.append(getNoteLine(line, prevLineList, file, lineCount, copyrightString, allLineList));
                                }
                                // 加入
                                stringBuilder.append(line + "\n");
                            }
                            // 赋值
                            prevLineList.add(line);
                        }
                        // 尝试下面的代码
                        try {
                            // 创建
                            BufferedWriter out = new BufferedWriter(new FileWriter(file));
                            // 写入
                            out.write(stringBuilder.toString());
                            // 关闭
                            out.close();
                            // 捕捉异常
                        } catch (Exception e) {
                            // 打印异常
                            e.printStackTrace();
                        }
                        // 捕捉异常
                    } catch (Exception e) {
                        // 打印异常
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    // 判断是否不需要增加注释
    private static boolean isNotNeedToAddNoteLine(String line, List<String> prevLineList) {
        // 字符串赋值
        String prevLine = prevLineList.get(prevLineList.size() - 1);
        // 是否是注释
        return isNoteLine(line)
            // 上一行是否是不是*/的注释
            || isNotePrevLine(prevLine)
            // 是空
            || line.trim().isEmpty()
            // 或判断
            || (
            // 判断
            line.trim().startsWith("\"")
                // 与判断
                && (line.trim().replace(" ", "").endsWith("\"")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\"+")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\", ")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\")")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\");")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\"), ")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\")}")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\")}, ")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\")};")
                // 或判断
                || line.trim().replace(" ", "").endsWith("\";")
                // 或判断
                || line.trim().replace(" ", "").endsWith("+")
            ))
            // 引入包不注释
            || line.trim().startsWith("import ")
            // 左花括号不注释
            || line.trim().replace(" ", "").equals("(")
            // 左花括号不注释
            || line.trim().replace(" ", "").equals("((")
            // 左花括号不注释
            || line.trim().replace(" ", "").equals("(((")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals(")")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals(");")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("), ")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("))")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals(")))")
            // 左花括号不注释
            || line.trim().replace(" ", "").equals("{")
            // 左花括号不注释
            || line.trim().replace(" ", "").equals("{{")
            // 左花括号不注释
            || line.trim().replace(" ", "").equals("{{{")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("}")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("};")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("}, ")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("}}")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("}}}")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals(")};")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("});")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("}), ")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals(")}")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("})")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("({")
            // 右花括号不注释
            || line.trim().replace(" ", "").equals("{(")
            // 括号不加注释
            || line.trim().replace(" ", "").equals("){")
            // 括号不加注释
            || line.trim().replace(" ", "").equals("\";")
            // 打日志不注释
            || (line.trim().toLowerCase().contains(".info(") && line.trim().toLowerCase().contains("log"))
            // 打日志不注释
            || (line.trim().toLowerCase().contains(".debug(") && line.trim().toLowerCase().contains("log"))
            // 打日志不注释
            || (line.trim().toLowerCase().contains(".warn(") && line.trim().toLowerCase().contains("log"))
            // 打日志不注释
            || (line.trim().toLowerCase().contains(".error(") && line.trim().toLowerCase().contains("log"));
    }

    // 根据判断拿到注释行
    private static String getNoteLine(String line, List<String> prevLineList, File file, Integer lineCount, String copyrightString, List<String> allLineList) {
        // 字符串赋值
        String prevLine = prevLineList.get(prevLineList.size() - 1);
        // 开始增加注释了
        String noteLine = "";
        // 判断
        if (line.startsWith("package ")) {
            // 判断
            if (lineCount == 1) {
                // 加入
                noteLine += getStartSpace(line) + "/**\n * " +
                    // 加入版权消息
                    getStartSpace(line) + copyrightString +
                    // 加入
                    getStartSpace(line) + "*/\n" +
                    "\n";
                // 否则
            } else {
                // 判断
                if (!prevLine.equals("")) {
                    // 加入
                    noteLine += "\n";
                    // 否则
                }
            }
            // 判断
            return noteLine;
        }
        // 判断
        if (line.trim().startsWith("public ") || line.trim().startsWith("protected")) {
            // 判断如果上一行不是以*/开头
            if (!prevLine.trim().startsWith("*/")) {
                // 增加javadoc
                noteLine += (getStartSpace(line) + "/**\n");
                // 上一行是//的注释
                if (prevLine.trim().startsWith("//")) {
                    // 加入上一行注释的文档
                    noteLine += getStartSpace(line) + " * " + prevLine.trim().replace("//", "") + "\n";
                    // 否则
                } else {
                    // 加入
                    noteLine += getStartSpace(line) + " * " + getNoteDescriptionFromThisLine(line, file);
                }
                // 增加javadoc
                noteLine += (getStartSpace(line) + "*/\n");
            }
            // 判断
            return noteLine;
        }
        // 判断如果上一行是以*/开头
        if (prevLine.trim().startsWith("*/")) {
            // 返回空字符串
            return "";
        }
        // 增加
        noteLine += getStartSpace(line) + "// ";
        // 描述
        noteLine += getNoteDescriptionFromThisLine(line, file);
        // 返回
        return noteLine;
    }

    //获取note描述
    private static String getNoteDescriptionFromThisLine(String line, File file) {
        String noteLine = "";
        // 抛出异常
        if (line.contains("throw new ")) {
            // 加入
            noteLine += "抛出异常";
            // 如果包含
        } else if (line.contains("@RequestHeader")) {
            // 加入
            noteLine += "请求消息头";
            // 如果包含
        } else if (line.contains("@RequestBody")) {
            // 加入
            noteLine += "请求消息体";
            // 如果包含
        } else if (line.contains("@RestController")) {
            // 加入
            noteLine += "控制器注解";
            // 如果包含
        } else if (line.contains("@Controller")) {
            // 加入
            noteLine += "控制器注解";
            // 如果包含
        } else if (line.contains("@RequestMapping")) {
            // 加入
            noteLine += "请求匹配";
            // 如果包含
        } else if (line.contains("@PostMapping")) {
            // 加入
            noteLine += "POST请求匹配";
            // 如果包含
        } else if (line.contains("@GetMapping")) {
            // 加入
            noteLine += "GET请求匹配";
            // 如果包含
        } else if (line.contains("@DeleteMapping")) {
            // 加入
            noteLine += "DELETE请求匹配";
            // 如果包含
        } else if (line.contains("@PutMapping")) {
            // 加入
            noteLine += "PUT请求匹配";
            // 如果包含
        } else if (line.contains("@PathVariable")) {
            // 加入
            noteLine += "路径变量匹配";
            // 如果包含
        } else if (line.contains("@SpringBootApplication")) {
            // 加入
            noteLine += "SpringBoot程序的最主要注解";
            // 如果包含
        } else if (line.contains("@Service")) {
            // 加入
            noteLine += "服务注解";
            // 如果包含
        } else if (line.contains("@Component")) {
            // 加入
            noteLine += "组件注解";
            // 如果包含
        } else if (line.contains("@Configuration")) {
            // 加入
            noteLine += "配置注解";
            // 如果包含
        } else if (line.contains("@Value")) {
            // 加入
            noteLine += "依赖注入值的注解";
            // 如果包含
        } else if (line.contains("@PostConstruct")) {
            // 加入
            noteLine += "延后构造注解";
            // 如果包含
        } else if (line.contains("@ControllerAdvice")) {
            // 加入
            noteLine += "控制器拦截注解";
            // 如果包含
        } else if (line.contains("@ResponseBody")) {
            // 加入
            noteLine += "将java对象转为json的注解";
            // 如果包含
        } else if (line.contains("@Bean")) {
            // 加入
            noteLine += "把对象构造出来注入容器的注解";
            // 如果包含
        } else if (line.contains("@Override")) {
            // 加入
            noteLine += "覆盖父类方法的注解";
            // 如果包含
        } else if (line.trim().startsWith("@")) {
            // 加入
            noteLine += "注解";
            // 如果包含
        } else if (line.trim().startsWith("return ")) {
            // 加入
            noteLine += "返回";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("return;")) {
            // 加入
            noteLine += "返回";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("static{")) {
            // 加入
            noteLine += "静态代码块";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("default:")) {
            // 加入
            noteLine += "默认";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("break;")) {
            // 加入
            noteLine += "跳出";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("continue;")) {
            // 加入
            noteLine += "继续";
            // 如果包含
        } else if (line.contains(" break ")) {
            // 加入
            noteLine += "跳出";
            // 如果包含
        } else if (line.trim().replace(" ", "").startsWith("if(") && line.trim().replace(" ", "").contains("==null")) {
            // 加入
            noteLine += "判断是否是空";
            // 如果包含
        } else if (line.trim().replace(" ", "").startsWith("if(") && line.trim().replace(" ", "").contains("!=null")) {
            // 加入
            noteLine += "判断是否非空";
            // 如果包含
        } else if (line.contains(" if(") || line.contains(" if (")) {
            // 加入
            noteLine += "判断";
            // 如果包含
        } else if (line.contains(" for(") || line.contains(" for (")) {
            // 加入
            noteLine += "遍历";
            // 如果包含
        } else if (line.contains(" while(") || line.contains(" while (")) {
            // 加入
            noteLine += "循环";
            // 如果包含
        } else if (line.contains(" = null ")) {
            // 加入
            noteLine += "赋值成空";
            // 如果包含
        } else if (line.trim().contains("String toString()")) {
            // 加入
            noteLine += "转换成字符串方法";
            // 如果包含
        } else if (line.contains("=new ")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.contains(" new ")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.contains(" = \"")) {
            // 加入
            noteLine += "赋值";
            // 如果包含
        } else if (line.contains("switch")) {
            // 加入
            noteLine += "判断";
            // 如果包含
        } else if (line.contains(" case ") && line.contains(":")) {
            // 加入
            noteLine += "判断";
            // 如果包含
        } else if (line.contains("+=")) {
            // 加入
            noteLine += "增加";
            // 如果包含
        } else if (line.contains("-=")) {
            // 加入
            noteLine += "减少";
            // 如果包含
        } else if (line.contains(" = ") && !line.contains("(")) {
            // 加入
            noteLine += "赋值";
            // 如果包含
        } else if (line.contains(".close()")) {
            // 加入
            noteLine += "关闭";
            // 如果包含
        } else if (line.contains(".write(")) {
            // 加入
            noteLine += "写入";
            // 如果包含
        } else if (line.contains(" || ")) {
            // 加入
            noteLine += "或判断";
            // 如果包含
        } else if (line.contains(" && ")) {
            // 加入
            noteLine += "与判断";
            // 如果包含
        } else if (line.contains("static final Logger")) {
            // 加入
            noteLine += "日志对象";
            // 如果包含
        } else if (line.contains(".replace")) {
            // 加入
            noteLine += "替换";
            // 如果包含
        } else if (line.contains("parse")) {
            // 加入
            noteLine += "转换";
            // 如果包含
        } else if (!line.contains("(") && !line.contains("{")
            // 与判断
            && !line.contains("}") && !line.contains(")") && !line.contains("=")
            // 如果首字母大写
            && line.trim().codePointAt(0) >= 65 && line.trim().codePointAt(0) <= 90
        ) {
            // 加入
            noteLine += "定义";
            // 如果包含
        } else if (!line.contains("(") && !line.contains("{")
            // 与判断
            && !line.contains("}") && !line.contains(")") && !line.contains("=")
            // 如果是8种基本类型
            && (line.trim().startsWith("byte ")
            // 或判断
            || line.trim().startsWith("int ")
            // 或判断
            || line.trim().startsWith("boolean ")
            // 或判断
            || line.trim().startsWith("char ")
            // 或判断
            || line.trim().startsWith("long ")
            // 或判断
            || line.trim().startsWith("double ")
            // 或判断
            || line.trim().startsWith("short ")
            // 或判断
            || line.trim().startsWith("float ")
        )
        ) {
            // 加入
            noteLine += "定义";
            // 如果包含
        } else if (line.contains("Calendar.getInstance();")) {
            // 加入
            noteLine += "拿到日历对象";
            // 如果包含
        } else if (line.contains(".add(Calendar.")) {
            // 加入
            noteLine += "调整日历";
            // 如果包含
        } else if (line.contains("System.getProperty(\"os.name\")")) {
            // 加入
            noteLine += "拿操作系统";
            // 如果包含
        } else if (line.toLowerCase().contains("copy(")) {
            // 加入
            noteLine += "拷贝";
            // 如果包含
        } else if (line.toLowerCase().contains("create(")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.toLowerCase().contains("delete(")) {
            // 加入
            noteLine += "删除";
            // 如果包含
        } else if (line.toLowerCase().contains("add(")) {
            // 加入
            noteLine += "增加";
            // 如果包含
        } else if (line.toLowerCase().contains("update(")) {
            // 加入
            noteLine += "更改";
            // 如果包含
        } else if (line.toLowerCase().contains("query(")) {
            // 加入
            noteLine += "查询";
            // 如果包含
        } else if (line.toLowerCase().contains("select(")) {
            // 加入
            noteLine += "选择";
            // 如果包含
        } else if (line.toLowerCase().contains("listFile(")) {
            // 加入
            noteLine += "拿文件列表";
            // 如果包含
        } else if (line.toLowerCase().contains("list(")) {
            // 加入
            noteLine += "拿列表";
            // 如果包含
        } else if (line.toLowerCase().contains("foreach(")) {
            // 加入
            noteLine += "遍历";
            // 如果包含
        } else if (line.toLowerCase().contains("contains(")) {
            // 加入
            noteLine += "包含";
            // 如果包含
        } else if (line.toLowerCase().contains(".copy")) {
            // 加入
            noteLine += "拷贝";
            // 如果包含
        } else if (line.toLowerCase().contains(".create")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.toLowerCase().contains(".delete")) {
            // 加入
            noteLine += "删除";
            // 如果包含
        } else if (line.toLowerCase().contains(".add")) {
            // 加入
            noteLine += "增加";
            // 如果包含
        } else if (line.toLowerCase().contains(".update")) {
            // 加入
            noteLine += "更改";
            // 如果包含
        } else if (line.toLowerCase().contains(".query")) {
            // 加入
            noteLine += "查询";
            // 如果包含
        } else if (line.toLowerCase().contains(".select")) {
            // 加入
            noteLine += "选择";
            // 如果包含
        } else if (line.toLowerCase().contains(".listFile")) {
            // 加入
            noteLine += "拿文件列表";
            // 如果包含
        } else if (line.toLowerCase().contains(".list")) {
            // 加入
            noteLine += "拿列表";
            // 如果包含
        } else if (line.toLowerCase().contains(".foreach")) {
            // 加入
            noteLine += "遍历";
            // 如果包含
        } else if (line.toLowerCase().contains(".contains")) {
            // 加入
            noteLine += "包含";
            // 如果包含
        } else if (line.toLowerCase().contains(".orElse(")) {
            // 加入
            noteLine += "如果是空拿到默认值，如果非空拿到对象";
            // 如果包含
        } else if (line.toLowerCase().contains(".equals(")) {
            // 加入
            noteLine += "相等";
            // 如果包含
        } else if (line.toLowerCase().contains("boolean equals(")) {
            // 加入
            noteLine += "相等方法";
            // 如果包含
        } else if (line.toLowerCase().contains(".findFirst(")) {
            // 加入
            noteLine += "找到第一个操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".count(")) {
            // 加入
            noteLine += "计数操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".anyMatch(")) {
            // 加入
            noteLine += "任意匹配操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".collect(")) {
            // 加入
            noteLine += "收集操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".filter(")) {
            // 加入
            noteLine += "过滤操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".stream()")) {
            // 加入
            noteLine += "流操作";
            // 如果包含
        } else if (line.toLowerCase().contains("->")) {
            // 加入
            noteLine += "lamda表达式";
            // 如果包含
        } else if (line.trim().startsWith("String ")) {
            // 加入
            noteLine += "字符串赋值";
            // 如果包含
        } else if (line.trim().startsWith("int ")) {
            // 加入
            noteLine += "数字赋值";
            // 如果包含
        } else if (line.trim().startsWith("Integer ")) {
            // 加入
            noteLine += "数字赋值";
            // 如果包含
        } else if (line.contains("Runtime.getRuntime().exec(")) {
            // 加入
            noteLine += "执行命令";
            // 如果包含
        } else if (line.contains(".getInputStream(")) {
            // 加入
            noteLine += "拿到输入流";
            // 如果包含
        } else if (line.contains(".split(")) {
            // 加入
            noteLine += "切分";
            // 如果包含
        } else if (line.contains("Thread.sleep(")) {
            // 加入
            noteLine += "休眠";
            // 如果包含
        } else if (line.contains("++")) {
            // 加入
            noteLine += "加1";
            // 如果包含
        } else if (line.contains("--")) {
            // 加入
            noteLine += "减1";
            // 如果包含
        } else if (line.contains("DriverManager.getConnection(")) {
            // 加入
            noteLine += "拿连接";
            // 如果包含
        } else if (line.contains("Connection connection =")) {
            // 加入
            noteLine += "拿连接";
            // 如果包含
        } else if (line.contains(" catch ")) {
            // 加入
            noteLine += "捕捉异常";
            // 如果包含
        } else if (line.contains("}catch ")) {
            // 加入
            noteLine += "捕捉异常";
            // 如果包含
        } else if (line.contains(" finally")) {
            // 加入
            noteLine += "最终执行";
            // 如果包含
        } else if (line.replace(" ", "").contains("}finally{")) {
            // 加入
            noteLine += "最终执行";
            // 如果包含
        } else if (line.contains("e.printStackTrace();")) {
            // 加入
            noteLine += "打印异常";
            // 如果包含
        } else if (line.contains("Pattern.compile(")) {
            // 加入
            noteLine += "编译正则表达式模板";
            // 如果包含
        } else if (line.contains("Matcher matcher = ")) {
            // 加入
            noteLine += "正则表达式匹配";
            // 如果包含
        } else if (line.contains(".matcher(")) {
            // 加入
            noteLine += "正则表达式匹配";
            // 如果包含
        } else if (line.trim().startsWith("throws ")) {
            // 加入
            noteLine += "抛出异常";
            // 如果包含
        } else if (line.trim().contains(".substring(")) {
            // 加入
            noteLine += "拿子字符串";
            // 如果包含
        } else if (line.trim().contains("System.getProperty(")) {
            // 加入
            noteLine += "拿系统变量";
            // 如果包含
        } else if (line.trim().contains(".mkdirs(")) {
            // 加入
            noteLine += "创建目录";
            // 如果包含
        } else if (line.trim().replace(" ", "").contains("else{")) {
            // 加入
            noteLine += "否则";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("else")) {
            // 加入
            noteLine += "否则";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("try{")) {
            // 加入
            noteLine += "尝试下面的代码";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("try(")) {
            // 加入
            noteLine += "尝试下面的代码";
            // 如果包含
        } else if (line.trim().startsWith("public void set")
            // 如果set后面的字母大写
            && line.trim().codePointAt(15) >= 65 && line.trim().codePointAt(15) <= 90
        ) {
            // 加入
            noteLine += "自动生成默认写入器";
            // 如果包含
        } else if (line.trim().startsWith("this.") && line.trim().contains(" = ")) {
            // 加入
            noteLine += "自动生成默认写入器写入属性";
            // 如果包含
        } else if (line.trim().startsWith("public ")
            // 与判断
            && line.trim().split(" ").length > 3
            // 与判断
            && line.trim().split(" ")[2].startsWith("get")
            // 如果get后面的字母大写
            && line.trim().split(" ")[2].codePointAt(3) >= 65
            // 与判断
            && line.trim().split(" ")[2].codePointAt(3) <= 90
            // 与判断
            && line.trim().contains("()")
        ) {
            // 加入
            noteLine += "自动生成默认获取器";
            // 如果包含
        } else if (line.trim().contains("public static void main(String[] args) {")) {
            // 加入
            noteLine += "jar包主函数";
            // 如果包含
        } else if (line.trim().contains(".append(")) {
            // 加入
            noteLine += "增加字符串";
            // 如果包含
        } else if (line.trim().contains("list.get(")) {
            // 加入
            noteLine += "从列表里拿数据";
            // 如果包含
        } else if (line.trim().contains(".execute(")) {
            // 加入
            noteLine += "执行";
            // 如果包含
        } else if (line.trim().contains(".toString(")) {
            // 加入
            noteLine += "转换成字符串";
            // 如果包含
        } else if (line.trim().contains(" run(")) {
            // 加入
            noteLine += "运行";
            // 如果包含
        } else if (line.trim().startsWith("@Test")) {
            // 加入
            noteLine += "单例测试注解";
            // 如果包含
        } else if (line.trim().startsWith("HttpEntity ")) {
            // 加入
            noteLine += "获取网页内容";
            // 如果包含
        } else if (line.trim().startsWith("String[] ")) {
            // 加入
            noteLine += "切分";
            // 如果包含
        } else if (line.trim().contains(".put(")) {
            // 加入
            noteLine += "塞入";
            // 如果包含
        } else if (line.trim().contains(".get(")) {
            // 加入
            noteLine += "拿出";
            // 如果包含
        } else if (line.trim().contains(".valueOf(")) {
            // 加入
            noteLine += "转换值";
            // 如果包含
        } else if (line.trim().contains(".flush(")) {
            // 加入
            noteLine += "清空内存的缓冲区数据";
            // 如果包含
        } else if (line.trim().contains(".exec(")) {
            // 加入
            noteLine += "执行命令";
            // 如果包含
        } else if (line.trim().contains(".prepareStatement(")) {
            // 加入
            noteLine += "准备表达式";
            // 如果包含
        } else if (line.trim().contains(".clear()")) {
            // 加入
            noteLine += "清除掉";
            // 如果包含
        } else if (line.trim().contains(" / ")) {
            // 加入
            noteLine += "计算";
            // 如果包含
        } else if (line.trim().contains(".sort(")) {
            // 加入
            noteLine += "排序";
            // 如果包含
        } else if (line.trim().contains("public int compare(")) {
            // 加入
            noteLine += "比较";
            // 如果包含
        } else if (line.trim().contains(".listFiles(")) {
            // 加入
            noteLine += "拿文件列表";
            // 如果包含
        } else if (line.trim().contains("System.out.println")) {
            // 加入
            noteLine += "打印";
            // 如果包含
        } else if (line.trim().contains("new InputStreamReader(")) {
            // 加入
            noteLine += "创建流阅读器";
            // 否则
        } else if (line.trim().contains("regEx")) {
            // 加入
            noteLine += "正则表达式";
            // 否则
        } else if (line.trim().contains(".setOrderByClause(")) {
            // 加入
            noteLine += "设置排序";
            // 否则
        } else if (line.trim().contains(".setLimit(")) {
            // 加入
            noteLine += "设置返回条数";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else if (line.trim().contains("zzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else {
            // 字符串赋值
            String className = file.getName().split("\\.")[0];
            // 判断
            if (line.contains(" " + className + "()")
            ) {
                // 加入
                noteLine += "构造函数";
                // 否则
            } else {
                // 增加
                noteLine += getTranslateNoteLine(line);
            }
        }
        // 加入
        noteLine += "\n";
        // 返回
        return noteLine;
    }

    // 字符串翻译
    private static String getTranslateNoteLine(String line) {
        // 赋值
        String noteLine = "";
        // 赋值
        String tempLine = "";
        // 创建
        Set<String> translateWords = new HashSet<>();
        // 替换
        line = line.split("\\(")[0]
            // 替换
            .replace("static ", "")
            // 替换
            .replace("public ", "")
            // 替换
            .replace("protected ", "")
            // 替换
            .replace("class ", "")
            // 替换
            .replace("SimpleResponse ", "")
            // 替换
            .replace("ListResponse ", "")
            // 替换
            .replace("ListResponseLong ", "")
            // 替换
            .replace("private ", "");
        // 遍历
        for (int i = 0; i < line.length(); i++) {
            // 判断
            if (line.codePointAt(i) >= 65 && line.codePointAt(i) <= 90) {
                // 判断
                if (tempLine.length() >= TRANSLATE_WORD_MIN_SIZE) {
                    // 增加
                    translateWords.add(tempLine.toLowerCase(Locale.ROOT));
                }
                // 赋值
                tempLine = "";
                // 增加
                tempLine += line.charAt(i);
                // 如果是小写字母
            } else if (line.codePointAt(i) >= 97 && line.codePointAt(i) < 122) {
                // 增加
                tempLine += line.charAt(i);
                // 如果是空格
            } else if (line.codePointAt(i) == 32) {
                // 判断
                if (tempLine.length() >= TRANSLATE_WORD_MIN_SIZE) {
                    // 增加
                    translateWords.add(tempLine.toLowerCase(Locale.ROOT));
                }
                // 赋值
                tempLine = "";
                // 否则
            } else {
                // 判断
                if (tempLine.length() >= TRANSLATE_WORD_MIN_SIZE) {
                    // 增加
                    translateWords.add(tempLine.toLowerCase(Locale.ROOT));
                }
                // 赋值
                tempLine = "";
            }
        }
        // 判断
        if (tempLine.length() >= TRANSLATE_WORD_MIN_SIZE) {
            // 增加
            translateWords.add(tempLine.toLowerCase(Locale.ROOT));
        }
        System.out.println(line);
        // 打印
        System.out.println(CacheJsonUtil.toJson(translateWords));
        // 加入
        noteLine += "";
        // 遍历
        for (String translateWord : translateWords) {
            // 增加
            noteLine += CacheTranslateUtil.translateToString(translateWord, "en", "zh");
            // 尝试下面的代码
            try {
                // 休眠
                Thread.sleep(200);
                // 捕捉异常
            } catch (InterruptedException e) {
                // 打印异常
                e.printStackTrace();
            }
        }
        // 返回
        return noteLine;
    }

    // 拿行开头的空白字符串
    private static String getStartSpace(String line) {
        // 赋值
        String startSpace = "";
        // 遍历
        for (int i = 0; i < line.length() - 1; i++) {
            // 判断
            if (" ".equals(line.substring(i, i + 1))) {
                // 赋值
                startSpace += " ";
                // 否则
            } else {
                // 跳出
                break;
            }
        }
        // 返回
        return startSpace;
    }

    // 上一行是否是不是*/的注释
    private static boolean isNotePrevLine(String line) {
        // 定义
        String firstLetter = null;
        // 尝试下面的代码
        try {
            // 拿前2个字符
            firstLetter = line.trim().substring(0, 1);
            // 捕捉异常
        } catch (Exception e) {
            // 置空
            firstLetter = "";
        }
        // 返回
        return ("/".equals(firstLetter)) && (!line.trim().replace(" ", "").equals("// TODO"));
    }

    // 当前行是否是注释
    private static boolean isNoteLine(String line) {
        // 定义
        String firstLetter = null;
        // 尝试下面的代码
        try {
            // 拿前1个字符
            firstLetter = line.trim().substring(0, 1);
            // 捕捉异常
        } catch (Exception e) {
            // 置空
            firstLetter = "";
        }
        // 赋值
        String last2Letter = null;
        // 尝试下面的代码
        try {
            // 拿最后2个字符
            last2Letter = line.trim().substring(line.length() - 2, line.length());
            // 捕捉异常
        } catch (Exception e) {
            // 置空
            last2Letter = "";
        }
        // 返回
        return ("*/".equals(last2Letter) || "/".equals(firstLetter) || "*".equals(firstLetter)) && (!line.trim().replace(" ", "").equals("// TODO"));
    }

}
